一、栈的压入 与退出
思想：本题要求的是一段push数字压入栈，判断另一vector中的数据是不是出栈的顺序，
建立一个新栈，将push数据一一压进，压进一个就和vector比较一下，如果相等，说明栈出来了数据，就将vector和栈都移到下一位，不相等就压栈，直到push空，
此时如果栈空，说明元素都出来了就是正确的，否则不正确。

class Solution {
public:
    bool validateStackSequences(vector<int>& pushed, vector<int>& popped) {
        stack<int> s;
        int cur=0;
        if(pushed.size()==0&&popped.size()==0)
        {
            return true;
        }
        if(pushed.size()==0||popped.size()==0)
        {
            return false;
        }
       
        for(int i=0;i<pushed.size();++i)
        {
            s.push(pushed[i]);

            while(!s.empty()&&s.top()==popped[cur])
            {
                s.pop();
                cur++;
            }
            
        }
        return s.empty();
    }
};

2、判断B树是不是A树的子树
思想：
第一步：判断A的根和B的根是不是相等，如果相等，则说明A、B的给、起始节点一样，那么就依次比较A、B左右子树是不是一样，
第二步：如果A、B的子树根不相等，则说明起始根不一样，则利用递归，将B依次与A的左右子树比较，
总结一条：就是先找B根和A中相等的节点，则比较其左右。
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    bool _isSubStructure(TreeNode* A, TreeNode* B)
    {
        if(B==nullptr)
        {
            return true;
        }
        if(A==nullptr)
        {
            return false;
        }
        return _isSubStructure(A->left,B->left)&&_isSubStructure(A->right,B->right);
    }
    bool isSubStructure(TreeNode* A, TreeNode* B) {
        if(A==nullptr&&B==nullptr)
        {
            return true;
        }
        if(A==nullptr||B==nullptr)
        {
            return false;
        }
        if(A->val==B->val)
        {
            return _isSubStructure(A->left,B)||_isSubStructure(A->right,B);
        }
        else
        {
            return isSubStructure(A->left,B)||isSubStructure(A->right,B);
        }
    }
};
3、一群数字中，求最小的k个数
思想：将一串树加载到优先级队列中，因为优先级队列底层是大堆，所以顶部都是最大的，就可以很方便的求出了
class Solution {
public:
    vector<int> getLeastNumbers(vector<int>& arr, int k) {
        vector<int> v;
        priority_queue<int,vector<int>,greater<int>> pq;
        for(auto e:arr)
        {
            pq.push(e);      
        }
        for(int i=0;i<k;i++)
        {
            v.push_back(pq.top());
            pq.pop();
        }
        return v;
    }
};